home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / optivc16 / mcdstd.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-03-06  |  30.1 KB  |  591 lines
  1. /*  MCDstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "dComplex"
  5.   (double-precision complex numbers)
  6.  
  7.   Copyright (c) 1996-1999 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MATLIB_H )
  12.    #include <MatLib.h>
  13. #endif
  14. #if !defined( __VCDSTD_H )
  15.    #include <VCDstd.h>
  16. #endif
  17.  
  18. #ifdef __cplusplus
  19. extern "C" {
  20. #endif
  21.  
  22. /*************   Dynamic Generation of Matrices   ************************/
  23.  
  24. cdMatrix __vf  MCD_matrix(  unsigned ht, unsigned len );
  25. cdMatrix __vf  MCD_matrix0( unsigned ht, unsigned len );
  26.     /*  notice that, in the memory model HUGE,
  27.         neither len nor ht may exceed 2047                */
  28.  
  29. /***************************************************************************
  30.  *  The following definitions ensure compatibility between dynamically     *
  31.  *  and statically allocated matrices. The definitions are somewhat        *
  32.  *  cumbersome, but the result for you is that you need not care about     *
  33.  *  the differences between the two types.                                 *
  34.  *  (Internally, the address of the first element of any matrix is needed; *
  35.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  36.  *  but yields in either case the correct address to be passed to the      *
  37.  *  function you wish to call.)                                            *
  38.  *  Only in the rare case that you need to pass the address of one of      *
  39.  *  these functions as an argument to another function, you have to use    *
  40.  *  the actual run-time functions defined further below. Be careful with   *
  41.  *  this: future development of compilers may allow us to avoid this un-   *
  42.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  43.  *  use these run-time names.                                              *
  44.  ***************************************************************************/
  45.  
  46.  
  47. /***  Addressing single elements of dynamically allocated matrices: ******
  48.      These two functions are for compatibility with Pascal
  49.      (where elements of dynamically allocated matrices are not directly
  50.      accessible), and for getting around the pointer arithmetics bug in
  51.      some versions of Borland C++.                                     */
  52.  
  53. #define MCD_Pelement( MA, ht, len, m, n ) MCDPelement( MA[0], ht, len, m, n )
  54.                      /* returns a pointer to MA[m][n]. */
  55. #define MCD_element( MA, ht, len, m, n ) *MCDPelement( MA[0], ht, len, m, n )
  56.                      /* dereferenced pointer */
  57.  
  58.  /****************  Initialization  ***************************************
  59.  
  60.     To initialize all elements of a matrix with the same value,
  61.     or to perform arithmetic operations on all elements simultaneously,
  62.     refer to the functions of VectorLib, declared in <VCDstd.h>, <VCDmath.h>.
  63.     In order to use the VectorLib functions, utilize the feature that
  64.     the whole matrix occupies one contiguous area in memory: pass the
  65.     address of the first row to the desired vector function, the size
  66.     of the "vector" being len * ht.
  67.     For example, initialize all elements of the matrix MA with {1.0, 0.0}
  68.     (this is *NOT* the identity matrix)  by calling
  69.         VCD_equ1( MA[0], len * ht );
  70. */
  71.  
  72. #define MCD_equ1( MA, len )                MCDequ1( MA[0], len )
  73.                        /* this is the identity matrix */
  74. #define MCD_outerprod( MA, X, Y, ht, len ) MCDouterprod( MA[0], X, Y, ht, len )
  75.                        /* sizX=ht, sizY=len */
  76. #define MCD_Row_equC( MA, ht, len, iRow, C ) \
  77.                                         MCDRow_equC( MA[0], ht, len, iRow, C )
  78. #define MCD_Col_equC( MA, ht, len, iCol, C ) \
  79.                                         MCDCol_equC( MA[0], ht, len, iCol, C )
  80. #define MCD_Dia_equC( MA, len, C )       MCDDia_equC( MA[0], len, C )
  81.  
  82. #define MCD_Row_equV( MA, ht, len, iRow, X ) \
  83.                                         MCDRow_equV( MA[0], ht, len, iRow, X )
  84. #define MCD_Col_equV( MA, ht, len, iCol, X ) \
  85.                                         MCDCol_equV( MA[0], ht, len, iCol, X )
  86. #define MCD_Dia_equV( MA, len, X )      MCDDia_equV( MA[0], len, X )
  87.  
  88. #define MCD_equM( MB, MA, ht, len )  VCD_equV( MB[0], MA[0], ((ui)(len))*(ht) )
  89.  
  90. #define MCD_UequL( MA, len ) MCDUequL( MA[0], len )
  91. #define MCD_LequU( MA, len ) MCDLequU( MA[0], len )
  92.          /* copy lower-diagonal elements into upper-diagonal
  93.            (or vice versa) by index-reflection, so as to
  94.            get a symmetric matrix    */
  95.  
  96.             /* data-type conversions:  */
  97. #define M_CDtoCF( MCF, MCD, ht, len ) V_CDtoCF( MCF[0], MCD[0], ((ui)ht)*len )
  98. #define M_CFtoCD( MCD, MCF, ht, len ) V_CFtoCD( MCD[0], MCF[0], ((ui)ht)*len )
  99. #define M_CEtoCD( MCD, MCE, ht, len ) V_CEtoCD( MCD[0], MCE[0], ((ui)ht)*len )
  100. #define M_CDtoCE( MCE, MCD, ht, len ) V_CDtoCE( MCE[0], MCD[0], ((ui)ht)*len )
  101.  
  102. /********  Extracting a submatrix and copying a submatrix back  *********/
  103.  
  104. #define MCD_submatrix( MSub, subHt, subLen, \
  105.                        MSrce, srceHt, srceLen, \
  106.                        firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  107.                MCDsubmatrix(  MSub[0], subHt, subLen, \
  108.                               MSrce[0], srceHt, srceLen, \
  109.                               firstRowInCol, sampInCol, firstColInRow, sampInRow )
  110.  
  111. #define MCD_submatrix_equM( MDest, destHt, destLen, \
  112.                             firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  113.                             MSrce, srceHt, srceLen ) \
  114.                MCDsubmatrix_equM(  MDest[0], destHt, destLen, \
  115.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  116.                              MSrce[0], srceHt, srceLen )
  117.  
  118. /*****   Extracting a single row or a single column or the diagonal  ******
  119.  *       and storing it into a vector                                     */
  120.  
  121. #define MCD_Row_extract( Y, MA, ht, len, iRow ) \
  122.                                      MCDRow_extract( Y, MA[0], ht, len, iRow )
  123. #define MCD_Col_extract( Y, MA, ht, len, iCol ) \
  124.                                      MCDCol_extract( Y, MA[0], ht, len, iCol )
  125. #define MCD_Dia_extract( Y, MA, len ) MCDDia_extract( Y, MA[0], len )
  126.  
  127.  
  128. /*****************    Basic arithmetic operations *********************
  129.                       performed on one single row,
  130.                       or one single column of any matrix,
  131.                       or on the diagonal of a square matrix
  132.  
  133.     Note: In contrast to the analogous VectorLib functions, the operations
  134.     are performed in-place, i.e. the input matrix itself is changed  */
  135.  
  136. #define MCD_Row_addC( MA, ht, len, iRow, C ) \
  137.                                      MCDRow_addC( MA[0], ht, len, iRow, C )
  138. #define MCD_Col_addC( MA, ht, len, iCol, C ) \
  139.                                      MCDCol_addC( MA[0], ht, len, iCol, C )
  140. #define MCD_Dia_addC( MA, len, C )   MCDDia_addC( MA[0], len, C )
  141.  
  142. #define MCD_Row_addV( MA, ht, len, iRow, X ) \
  143.                                      MCDRow_addV( MA[0], ht, len, iRow, X )
  144. #define MCD_Col_addV( MA, ht, len, iCol, X ) \
  145.                                      MCDCol_addV( MA[0], ht, len, iCol, X )
  146. #define MCD_Dia_addV( MA, len, X )   MCDDia_addV( MA[0], len, X )
  147.  
  148. #define MCD_Row_subC( MA, ht, len, iRow, C ) \
  149.                                      MCDRow_addC( MA[0], ht, len, iRow, (-C) )
  150. #define MCD_Col_subC( MA, ht, len, iCol, C ) \
  151.                                      MCDCol_addC( MA[0], ht, len, iCol, (-C) )
  152. #define MCD_Dia_subC( MA, len, C )   MCDDia_addC( MA[0], len, (-C) )
  153.  
  154. #define MCD_Row_subV( MA, ht, len, iRow, X ) \
  155.                                      MCDRow_subV( MA[0], ht, len, iRow, X )
  156. #define MCD_Col_subV( MA, ht, len, iCol, X ) \
  157.                                      MCDCol_subV( MA[0], ht, len, iCol, X )
  158. #define MCD_Dia_subV( MA, len, X )   MCDDia_subV( MA[0], len, X )
  159.  
  160. #define MCD_Row_subrC( MA, ht, len, iRow, C ) \
  161.                                      MCDRow_subrC( MA[0], ht, len, iRow, C )
  162. #define MCD_Col_subrC( MA, ht, len, iCol, C ) \
  163.                                      MCDCol_subrC( MA[0], ht, len, iCol, C )
  164. #define MCD_Dia_subrC( MA, len, C )  MCDDia_subrC( MA[0], len, C )
  165.  
  166. #define MCD_Row_subrV( MA, ht, len, iRow, X ) \
  167.                                      MCDRow_subrV( MA[0], ht, len, iRow, X )
  168. #define MCD_Col_subrV( MA, ht, len, iCol, X ) \
  169.                                      MCDCol_subrV( MA[0], ht, len, iCol, X )
  170. #define MCD_Dia_subrV( MA, len, X )  MCDDia_subrV( MA[0], len, X )
  171.  
  172. #define MCD_Row_mulC( MA, ht, len, iRow, C ) \
  173.                                      MCDRow_mulC( MA[0], ht, len, iRow, C )
  174. #define MCD_Col_mulC( MA, ht, len, iCol, C ) \
  175.                                      MCDCol_mulC( MA[0], ht, len, iCol, C )
  176. #define MCD_Dia_mulC( MA, len, C )   MCDDia_mulC( MA[0], len, C )
  177.  
  178. #define MCD_Row_mulV( MA, ht, len, iRow, X ) \
  179.                                      MCDRow_mulV( MA[0], ht, len, iRow, X )
  180. #define MCD_Col_mulV( MA, ht, len, iCol, X ) \
  181.                                      MCDCol_mulV( MA[0], ht, len, iCol, X )
  182. #define MCD_Dia_mulV( MA, len, X )   MCDDia_mulV( MA[0], len, X )
  183.  
  184. #define MCD_Row_divC( MA, ht, len, iRow, C ) \
  185.                                      MCDRow_divC( MA[0], ht, len, iRow, C )
  186. #define MCD_Col_divC( MA, ht, len, iCol, C ) \
  187.                                      MCDCol_divC( MA[0], ht, len, iCol, C )
  188. #define MCD_Dia_divC( MA, len, C )   MCDDia_divC( MA[0], len, C )
  189.  
  190. #define MCD_Row_divV( MA, ht, len, iRow, X ) \
  191.                                       MCDRow_divV( MA[0], ht, len, iRow, X )
  192. #define MCD_Col_divV( MA, ht, len, iCol, X ) \
  193.                                       MCDCol_divV( MA[0], ht, len, iCol, X )
  194. #define MCD_Dia_divV( MA, len, X )    MCDDia_divV( MA[0], len, X )
  195.  
  196. #define MCD_Row_divrC( MA, ht, len, iRow, C ) \
  197.                                       MCDRow_divrC( MA[0], ht, len, iRow, C )
  198. #define MCD_Col_divrC( MA, ht, len, iCol, C ) \
  199.                                       MCDCol_divrC( MA[0], ht, len, iCol, C )
  200. #define MCD_Dia_divrC( MA, len, C )   MCDDia_divrC( MA[0], len, C )
  201.  
  202. #define MCD_Row_divrV( MA, ht, len, iRow, X ) \
  203.                                       MCDRow_divrV( MA[0], ht, len, iRow, X )
  204. #define MCD_Col_divrV( MA, ht, len, iCol, X ) \
  205.                                       MCDCol_divrV( MA[0], ht, len, iCol, X )
  206. #define MCD_Dia_divrV( MA, len, X )   MCDDia_divrV( MA[0], len, X )
  207.  
  208.  
  209. /******  One-dimensional vector operations **********************
  210.          performed along all rows or all columns simultaneously,
  211.          or along the diagonal of a square matrix                */
  212.  
  213. #define MCD_Rows_absmax( Y, MA, ht, len )  MCDRows_absmax( Y, MA[0], ht, len )
  214. #define MCD_Cols_absmax( Y, MA, ht, len )  MCDCols_absmax( Y, MA[0], ht, len )
  215. #define MCD_Dia_absmax( MA, len )          MCDDia_absmax( MA[0], len )
  216. #define MCD_Rows_absmin( Y, MA, ht, len )  MCDRows_absmin( Y, MA[0], ht, len )
  217. #define MCD_Cols_absmin( Y, MA, ht, len )  MCDCols_absmin( Y, MA[0], ht, len )
  218. #define MCD_Dia_absmin( MA, len )          MCDDia_absmin( MA[0], len )
  219.  
  220. #define MCD_Rows_maxReIm( Y, MA, ht, len ) MCDRows_maxReIm( Y, MA[0], ht, len )
  221. #define MCD_Cols_maxReIm( Y, MA, ht, len ) MCDCols_maxReIm( Y, MA[0], ht, len )
  222. #define MCD_Dia_maxReIm( MA, len )         MCDDia_maxReIm( MA[0], len )
  223. #define MCD_Rows_minReIm( Y, MA, ht, len ) MCDRows_minReIm( Y, MA[0], ht, len )
  224. #define MCD_Cols_minReIm( Y, MA, ht, len ) MCDCols_minReIm( Y, MA[0], ht, len )
  225. #define MCD_Dia_minReIm( MA, len )         MCDDia_minReIm( MA[0], len )
  226.  
  227. #define MCD_Rows_absmaxReIm( Y, MA, ht, len ) MCDRows_absmaxReIm( Y, MA[0], ht, len )
  228. #define MCD_Cols_absmaxReIm( Y, MA, ht, len ) MCDCols_absmaxReIm( Y, MA[0], ht, len )
  229. #define MCD_Dia_absmaxReIm( MA, len )         MCDDia_absmaxReIm( MA[0], len )
  230. #define MCD_Rows_absminReIm( Y, MA, ht, len ) MCDRows_absminReIm( Y, MA[0], ht, len )
  231. #define MCD_Cols_absminReIm( Y, MA, ht, len ) MCDCols_absminReIm( Y, MA[0], ht, len )
  232. #define MCD_Dia_absminReIm( MA, len )         MCDDia_absminReIm( MA[0], len )
  233.  
  234. #define MCD_Rows_sum( Y, MA, ht, len )     MCDRows_sum( Y, MA[0], ht, len )
  235. #define MCD_Cols_sum( Y, MA, ht, len )     MCDCols_sum( Y, MA[0], ht, len )
  236. #define MCD_Dia_sum(  MA, len )            MCDDia_sum( MA[0], len )
  237. #define MCD_Rows_prod( Y, MA, ht, len )    MCDRows_prod( Y, MA[0], ht, len )
  238. #define MCD_Cols_prod( Y, MA, ht, len )    MCDCols_prod( Y, MA[0], ht, len )
  239. #define MCD_Dia_prod(  MA, len )           MCDDia_prod( MA[0], len )
  240.  
  241. #define MCD_Rows_runsum( MA, ht, len )     MCDRows_runsum( MA[0], ht, len )
  242. #define MCD_Cols_runsum( MA, ht, len )     MCDCols_runsum( MA[0], ht, len )
  243. #define MCD_Rows_runprod( MA, ht, len )    MCDRows_runprod( MA[0], ht, len )
  244. #define MCD_Cols_runprod( MA, ht, len )    MCDCols_runprod( MA[0], ht, len )
  245.  
  246. #define MCD_Rows_rotate( MA, ht, len, pos) MCDRows_rotate( MA[0], ht, len, pos )
  247. #define MCD_Cols_rotate( MA, ht, len, pos) MCDCols_rotate( MA[0], ht, len, pos )
  248.  
  249. /********  Operations involving two rows or two colums of one matrix  *****/
  250.  
  251. #define MCD_Rows_exchange( MA, ht, len, row1, row2 ) \
  252.                              MCDRows_exchange( MA[0], ht, len, row1, row2 )
  253. #define MCD_Cols_exchange( MA, ht, len, col1, col2 ) \
  254.                              MCDCols_exchange( MA[0], ht, len, col1, col2 )
  255.  
  256. #define MCD_Rows_add( MA, ht, len, destRow, srceRow ) \
  257.                              MCDRows_add( MA[0], ht, len, destRow, srceRow )
  258. #define MCD_Cols_add( MA, ht, len, destCol, srceCol ) \
  259.                              MCDCols_add( MA[0], ht, len, destCol, srceCol )
  260.                          /* dest[i] += source[i]  */
  261.  
  262. #define MCD_Rows_sub( MA, ht, len, destRow, srceRow ) \
  263.                              MCDRows_sub( MA[0], ht, len, destRow, srceRow )
  264. #define MCD_Cols_sub( MA, ht, len, destCol, srceCol ) \
  265.                              MCDCols_sub( MA[0], ht, len, destCol, srceCol )
  266.                          /* dest[i] -= source[i]  */
  267.  
  268. #define MCD_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  269.                           MCDRows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  270. #define MCD_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  271.                           MCDCols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  272.                          /* dest[i] += C * source[i]  */
  273.  
  274. #define MCD_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  275.             MCDRows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  276. #define MCD_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  277.             MCDCols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  278.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  279.  
  280.  
  281. /*************************  Transposing a matrix **********************/
  282.  
  283. #define MCD_transpose( MTr, MA, htTr, lenTr ) \
  284.              MCDtranspose( MTr[0], MA[0], htTr, lenTr )
  285.        /*  the dimensions htTr, lenTr are those of the transposed matrix,
  286.            not of the original!                */
  287.  
  288.  
  289. /************************ Matrix Multiplication *************************/
  290.  
  291. #define MCD_mulV( Y, MA, X, htA, lenA ) \
  292.                     MCDmulV( Y, MA[0], X, htA, lenA )
  293.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  294.                               both X and Y are column-vectors    */
  295. #define VCD_mulM( Y, X, MA, sizX, lenA ) \
  296.                     VCDmulM( Y, X, MA[0], 1, sizX, lenA )
  297.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  298.                              both X and Y are row-vectors.
  299.                              Mind the prefix: VCD_ (not MCD_)    */
  300. #define MCD_mulM( MC, MA, MB, htA, lenA, lenB ) \
  301.                     MCDmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  302.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  303.  
  304.  
  305. /***************** Two-Dimensional Fourier-Transform Methods ************/
  306.  
  307. #define MCDl_FFT( MY, MX, ht, len, dir )     MCDlFFT( MY[0], MX[0], ht, len, dir )
  308. #define MCDl_filter( MY, MX, MFlt, ht, len ) MCDlfilter( MY[0], MX[0], MFlt[0], ht, len )
  309.  
  310. #define MCDs_FFT( MY, MX, ht, len, dir )     MCDsFFT( MY[0], MX[0], ht, len, dir )
  311. #define MCDs_filter( MY, MX, MFlt, ht, len ) MCDsfilter( MY[0], MX[0], MFlt[0], ht, len )
  312.  
  313. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  314.    #define MCD_FFT         MCDl_FFT
  315.    #define MCD_filter      MCDl_filter
  316. #else
  317.    #define MCD_FFT         MCDs_FFT
  318.    #define MCD_filter      MCDs_filter
  319. #endif
  320.  
  321. /**************************  Input and Output  **************************/
  322.  
  323. #define MCD_fprint( stream, MA, ht, len, linewidth ) \
  324.                     MCDfprint( stream, MA[0], ht, len, linewidth )
  325. #define MCD_print( MA, ht, len )  MCDfprint( stdout, MA[0], ht, len, 80 )
  326. #define MCD_cprint( MA, ht, len ) MCDcprint( MA[0], ht, len )
  327.   /*  MCD_print, MCD_cprint usable only for DOS, EasyWin, and Win32 console applications! */
  328.  
  329. #define MCD_write( str, MA, ht, len )   MCDwrite( str, MA[0], ht, len )
  330. #define MCD_read( MA, ht, len, str )    MCDread( MA[0], ht, len, str )
  331. #define MCD_setWriteFormat              VCD_setWriteFormat
  332. #define MCD_setWriteSeparate            VCD_setNWriteSeparate
  333.                                    /* write and read in ascii format */
  334. #define MCD_store( str, MA, ht, len ) \
  335.                            VCD_store( str, MA[0], ((ui)(len))*(ht) );
  336. #define MCD_recall( MA, ht, len, str) \
  337.                            VCD_recall( MA[0], ((ui)(len))*(ht), str);
  338.                                   /* store and recall in binary format */
  339.  
  340.  
  341. /*************************************************************************
  342.  * Here are now the actual declarations of the functions used internally.*
  343.  * These declarations may change in future versions of MatrixLib!        *
  344.  * You should not care too much about them, except in the case you need  *
  345.  * the actual address of a run-time function (see above). Under all      *
  346.  * "normal" circumstances, use only the names defined above in the       *
  347.  * macro section!                                                        *
  348.  *************************************************************************/
  349.  
  350. dComplex _VFAR * MCDPelement( cdPMatrix X, unsigned ht, unsigned len,
  351.                               unsigned m, unsigned n );
  352.                   /* pointer is normalized in memory model HUGE */
  353.  
  354. void   __vf  MCDequ1( cdPMatrix MA, unsigned len );  /* identity matrix */
  355. void   __vf  MCDouterprod( cdPMatrix MA, cdVector X,  cdVector Y,
  356.                            unsigned ht, unsigned len );
  357.  
  358. void   __vf  MCDRow_equC( cdPMatrix MA, unsigned ht, unsigned len,
  359.                          unsigned iRow, dComplex C );
  360. void   __vf  MCDCol_equC( cdPMatrix MA, unsigned ht, unsigned len,
  361.                          unsigned iCol, dComplex C );
  362. void   __vf  MCDDia_equC( cdPMatrix MA, unsigned len, dComplex C );
  363.  
  364. void   __vf  MCDRow_equV( cdPMatrix MA, unsigned ht, unsigned len,
  365.                          unsigned iRow, cdVector X );
  366. void   __vf  MCDCol_equV( cdPMatrix MA, unsigned ht, unsigned len,
  367.                          unsigned iCol, cdVector X );
  368. void   __vf  MCDDia_equV( cdPMatrix MA, unsigned len, cdVector X );
  369.  
  370. void   __vf  MCDUequL( cdPMatrix MA, unsigned len );
  371. void   __vf  MCDLequU( cdPMatrix MA, unsigned len );
  372.  
  373. /********  Extracting a submatrix and copying a submatrix back  *********/
  374.  
  375. void  __vf  MCDsubmatrix( cdPMatrix MSub,
  376.                           unsigned subHt,  unsigned subLen,
  377.                           cdPMatrix MSrce,
  378.                           unsigned srceHt,  unsigned srceLen,
  379.                           unsigned firstRowInCol,  unsigned sampInCol,
  380.                           unsigned firstColInRow,  unsigned sampInRow );
  381.  
  382. void  __vf  MCDsubmatrix_equM( cdPMatrix MDest,
  383.                                unsigned destHt,     unsigned destLen,
  384.                                unsigned firstRowInCol,  unsigned sampInCol,
  385.                                unsigned firstColInRow,  unsigned sampInRow,
  386.                                cdPMatrix MSrce,
  387.                                unsigned srceHt,     unsigned srceLen );
  388.  
  389.  
  390. /*****   Extracting a single row or a single column or the diagonal  *****
  391.  *       and storing it into a vector                                    */
  392.  
  393. void __vf MCDRow_extract( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len,
  394.                            unsigned iRow );
  395. void __vf MCDCol_extract( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len,
  396.                            unsigned iCol );
  397. void __vf MCDDia_extract( cdVector Y, cdPMatrix MA, unsigned len );
  398.  
  399.  
  400. /*****************    Basic arithmetic operations ***********************
  401.      performed on one single row,  or one single column of any matrix,
  402.      or on the diagonal of a square matrix                              */
  403.  
  404. void   __vf  MCDRow_addC( cdPMatrix MA, unsigned ht, unsigned len,
  405.                          unsigned iRow, dComplex C );
  406. void   __vf  MCDCol_addC( cdPMatrix MA, unsigned ht, unsigned len,
  407.                          unsigned iCol, dComplex C );
  408. void   __vf  MCDDia_addC( cdPMatrix MA, unsigned len, dComplex C );
  409.  
  410. void   __vf  MCDRow_subC( cdPMatrix MA, unsigned ht, unsigned len,
  411.                          unsigned iRow, dComplex C );
  412. void   __vf  MCDCol_subC( cdPMatrix MA, unsigned ht, unsigned len,
  413.                          unsigned iCol, dComplex C );
  414. void   __vf  MCDDia_subC( cdPMatrix MA, unsigned len, dComplex C );
  415.  
  416. void   __vf  MCDRow_addV( cdPMatrix MA, unsigned ht, unsigned len,
  417.                          unsigned iRow, cdVector X );
  418. void   __vf  MCDCol_addV( cdPMatrix MA, unsigned ht, unsigned len,
  419.                          unsigned iCol, cdVector X );
  420. void   __vf  MCDDia_addV( cdPMatrix MA, unsigned len, cdVector X );
  421.  
  422. void   __vf  MCDRow_subV( cdPMatrix MA, unsigned ht, unsigned len,
  423.                          unsigned iRow, cdVector X );
  424. void   __vf  MCDCol_subV( cdPMatrix MA, unsigned ht, unsigned len,
  425.                          unsigned iCol, cdVector X );
  426. void   __vf  MCDDia_subV( cdPMatrix MA, unsigned len, cdVector X );
  427.  
  428. void   __vf  MCDRow_subrC( cdPMatrix MA, unsigned ht, unsigned len,
  429.                          unsigned iRow, dComplex C );
  430. void   __vf  MCDCol_subrC( cdPMatrix MA, unsigned ht, unsigned len,
  431.                          unsigned iCol, dComplex C );
  432. void   __vf  MCDDia_subrC( cdPMatrix MA, unsigned len, dComplex C );
  433.  
  434. void   __vf  MCDRow_subrV( cdPMatrix MA, unsigned ht, unsigned len,
  435.                          unsigned iRow, cdVector X );
  436. void   __vf  MCDCol_subrV( cdPMatrix MA, unsigned ht, unsigned len,
  437.                          unsigned iCol, cdVector X );
  438. void   __vf  MCDDia_subrV( cdPMatrix MA, unsigned len, cdVector X );
  439.  
  440. void   __vf  MCDRow_mulC( cdPMatrix MA, unsigned ht, unsigned len,
  441.                          unsigned iRow, dComplex C );
  442. void   __vf  MCDCol_mulC( cdPMatrix MA, unsigned ht, unsigned len,
  443.                          unsigned iCol, dComplex C );
  444. void   __vf  MCDDia_mulC( cdPMatrix MA, unsigned len, dComplex C );
  445.  
  446. void   __vf  MCDRow_mulV( cdPMatrix MA, unsigned ht, unsigned len,
  447.                          unsigned iRow, cdVector X );
  448. void   __vf  MCDCol_mulV( cdPMatrix MA, unsigned ht, unsigned len,
  449.                          unsigned iCol, cdVector X );
  450. void   __vf  MCDDia_mulV( cdPMatrix MA, unsigned len, cdVector X );
  451.  
  452. void   __vf  MCDRow_divC( cdPMatrix MA, unsigned ht, unsigned len,
  453.                          unsigned iRow, dComplex C );
  454. void   __vf  MCDCol_divC( cdPMatrix MA, unsigned ht, unsigned len,
  455.                          unsigned iCol, dComplex C );
  456. void   __vf  MCDDia_divC( cdPMatrix MA, unsigned len, dComplex C );
  457.  
  458. void   __vf  MCDRow_divV( cdPMatrix MA, unsigned ht, unsigned len,
  459.                          unsigned iRow, cdVector X );
  460. void   __vf  MCDCol_divV( cdPMatrix MA, unsigned ht, unsigned len,
  461.                          unsigned iCol, cdVector X );
  462. void   __vf  MCDDia_divV( cdPMatrix MA, unsigned len, cdVector X );
  463.  
  464. void   __vf  MCDRow_divrC( cdPMatrix MA, unsigned ht, unsigned len,
  465.                          unsigned iRow, dComplex C );
  466. void   __vf  MCDCol_divrC( cdPMatrix MA, unsigned ht, unsigned len,
  467.                          unsigned iCol, dComplex C );
  468. void   __vf  MCDDia_divrC( cdPMatrix MA, unsigned len, dComplex C );
  469.  
  470. void   __vf  MCDRow_divrV( cdPMatrix MA, unsigned ht, unsigned len,
  471.                          unsigned iRow, cdVector X );
  472. void   __vf  MCDCol_divrV( cdPMatrix MA, unsigned ht, unsigned len,
  473.                          unsigned iCol, cdVector X );
  474. void   __vf  MCDDia_divrV( cdPMatrix MA, unsigned len, cdVector X );
  475.  
  476.  
  477. /******  One-dimensional vector operations **********************
  478.          performed along all rows or all columns simultaneously,
  479.          or along the diagonal of a square matrix                */
  480.  
  481. void     __vf  MCDRows_absmax( dVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  482. void     __vf  MCDCols_absmax( dVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  483. double   __vf  MCDDia_absmax(  cdPMatrix MA, unsigned len );
  484. void     __vf  MCDRows_absmin( dVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  485. void     __vf  MCDCols_absmin( dVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  486. double   __vf  MCDDia_absmin(  cdPMatrix MA, unsigned len );
  487.  
  488. void     __vf  MCDRows_maxReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  489. void     __vf  MCDCols_maxReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  490. void     __vf  MCDRows_minReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  491. void     __vf  MCDCols_minReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  492.  
  493. void     __vf  MCDRows_absmaxReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  494. void     __vf  MCDCols_absmaxReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  495. void     __vf  MCDRows_absminReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  496. void     __vf  MCDCols_absminReIm( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  497.  
  498. void     __vf  MCDRows_sum( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  499. void     __vf  MCDCols_sum( cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  500. void     __vf  MCDRows_prod(cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  501. void     __vf  MCDCols_prod(cdVector Y, cdPMatrix MA, unsigned ht, unsigned len );
  502. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  503. } // the following functions cannot be extern "C", if dComplex is a class
  504. #endif
  505. dComplex __vf  MCDDia_maxReIm(  cdPMatrix MA, unsigned len );
  506. dComplex __vf  MCDDia_minReIm(  cdPMatrix MA, unsigned len );
  507. dComplex __vf  MCDDia_absmaxReIm(  cdPMatrix MA, unsigned len );
  508. dComplex __vf  MCDDia_absminReIm(  cdPMatrix MA, unsigned len );
  509. dComplex __vf  MCDDia_sum(  cdPMatrix MA, unsigned len );
  510. dComplex __vf  MCDDia_prod( cdPMatrix MA, unsigned len );
  511. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  512. extern "C" {
  513. #endif
  514.  
  515.  
  516. void  __vf  MCDRows_runsum( cdPMatrix MA, unsigned ht, unsigned len );
  517. void  __vf  MCDCols_runsum( cdPMatrix MA, unsigned ht, unsigned len );
  518. void  __vf  MCDRows_runprod( cdPMatrix MA, unsigned ht, unsigned len );
  519. void  __vf  MCDCols_runprod( cdPMatrix MA, unsigned ht, unsigned len );
  520.  
  521. void  __vf  MCDRows_rotate( cdPMatrix MA, unsigned ht, unsigned len, int pos );
  522. void  __vf  MCDCols_rotate( cdPMatrix MA, unsigned ht, unsigned len, int pos );
  523.  
  524. /********  Operations involving two rows or two colums of one matrix  *****/
  525.  
  526. void   __vf  MCDRows_exchange( cdPMatrix MA, unsigned ht, unsigned len,
  527.                               unsigned i1, unsigned i2 );
  528. void   __vf  MCDCols_exchange( cdPMatrix MA, unsigned ht, unsigned len,
  529.                               unsigned i1, unsigned i2 );
  530.  
  531. void   __vf  MCDRows_add( cdPMatrix MA, unsigned ht, unsigned len,
  532.                           unsigned destRow, unsigned sourceRow );
  533. void   __vf  MCDCols_add( cdPMatrix MA, unsigned ht, unsigned len,
  534.                           unsigned destCol, unsigned sourceCol );
  535.  
  536. void   __vf  MCDRows_sub( cdPMatrix MA, unsigned ht, unsigned len,
  537.                           unsigned destRow, unsigned sourceRow );
  538. void   __vf  MCDCols_sub( cdPMatrix MA, unsigned ht, unsigned len,
  539.                           unsigned destCol, unsigned sourceCol );
  540.  
  541. void   __vf  MCDRows_Cadd( cdPMatrix MA, unsigned ht, unsigned len,
  542.                            unsigned destRow, unsigned sourceRow, dComplex C );
  543. void   __vf  MCDCols_Cadd( cdPMatrix MA, unsigned ht, unsigned len,
  544.                            unsigned destCol, unsigned sourceCol, dComplex C );
  545.  
  546. void   __vf  MCDRows_lincomb( cdPMatrix MA, unsigned ht, unsigned len,
  547.                               unsigned destRow,  dComplex  destC,
  548.                               unsigned srceRow,  dComplex  srceC );
  549. void   __vf  MCDCols_lincomb( cdPMatrix MA, unsigned ht, unsigned len,
  550.                               unsigned destCol,  dComplex  destC,
  551.                               unsigned srceCol,  dComplex  srceC );
  552.  
  553.  
  554. /*************************  Transposing a matrix **********************/
  555.  
  556. void  __vf  MCDtranspose( cdPMatrix MTr, cdPMatrix MA,
  557.                           unsigned htTr, unsigned lenTr );
  558.  
  559.  
  560. /************************ Matrix Multiplication *************************/
  561.  
  562. void  __vf  MCDmulV( cdVector Y, cdPMatrix MA, cdVector X,
  563.                      unsigned htA, unsigned lenA );
  564. void  __vf  VCDmulM( cdVector Y, cdVector X, cdPMatrix MA,
  565.                      unsigned sizX, unsigned lenA );
  566. void  __vf  MCDmulM( cdPMatrix MC, cdPMatrix MA, cdPMatrix MB,
  567.                      unsigned htA, unsigned lenA, unsigned lenB );
  568.  
  569.  
  570. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  571.  
  572. void  __vf   MCDlFFT( cdPMatrix MY, cdPMatrix MX,
  573.                       unsigned ht, unsigned len, int dir );
  574. void  __vf   MCDlfilter( cdPMatrix MY, cdPMatrix MX, cdPMatrix MFlt,
  575.                          unsigned ht, unsigned len );
  576. void  __vf   MCDsFFT( cdPMatrix MY, cdPMatrix MX,
  577.                       unsigned ht, unsigned len, int dir );
  578. void  __vf   MCDsfilter( cdPMatrix MY, cdPMatrix MX, cdPMatrix MFlt,
  579.                          unsigned ht, unsigned len );
  580.  
  581.       /*************  Input and Output  ****************/
  582.  
  583. void __vf MCDfprint( FILE _VFAR *stream, cdPMatrix MA, unsigned ht,
  584.                      unsigned len, unsigned linewidth );
  585. void __vf MCDcprint( cdPMatrix MA, unsigned ht, unsigned len );
  586. void  __vf    MCDwrite( FILE _VFAR *stream, cdPMatrix X, unsigned ht, unsigned len  );
  587. void  __vf    MCDread( cdPMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  588.  
  589. #ifdef __cplusplus
  590. }
  591. #endif